package optional;

import org.junit.Test;
import ref.Employee;

import java.util.Optional;

/**
 * @Author com.alibaba.lizhen
 * @Date 2021/3/24 9:08 下午
 * @Version 1.0
 * @Description
 */
public class OptionalTest {
    /**
     * Optional.of(T t); // 创建一个Optional实例
     * Optional.empty(); // 创建一个空的Optional实例
     * Optional.ofNullable(T t); // 若T不为null，创建一个Optional实例，否则创建一个空实例
     * isPresent();    // 判断是够包含值
     * orElse(T t);   //如果调用对象包含值，返回该值，否则返回T
     * orElseGet(Supplier s);  // 如果调用对象包含值，返回该值，否则返回s中获取的值
     * map(Function f): // 如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty();
     * flatMap(Function mapper);// 与map类似。返回值是Optional
     * <p>
     * 总结：Optional.of(null)  会直接报NPE
     */

    /**
     * Optional.of(T t)  // 创建一个Optional实例
     */
    @Test
    public void test1() {
        Optional<Employee> op = Optional.of(new Employee("zhansan"));
        System.out.println(op.get());

        // NPE
        Optional<Employee> op2 = Optional.of(null);
        System.out.println(op2);
    }

    /**
     * Optional.empty(); // 创建一个空的Optional实例
     */
    @Test
    public void test2() {
        Optional<Object> op = Optional.empty();
        System.out.println(op);

        // No value present
        System.out.println(op.get());
    }

    /**
     * Optional.ofNullable(T t); // 若T不为null，创建一个Optional实例，否则创建一个空实例
     */
    @Test
    public void test3() {
        Optional<Employee> op = Optional.ofNullable(new Employee("lisi"));
        System.out.println(op.get());

        Optional<Object> op2 = Optional.ofNullable(null);
        System.out.println(op2);
        // System.out.println(op2.get());
    }

    /**
     * isPresent();    // 判断是够包含值
     * * orElse(T t);   //如果调用对象包含值，返回该值，否则返回T
     * * orElseGet(Supplier s);  // 如果调用对象包含值，返回该值，否则返回s中获取的值
     * * map(Function f): // 如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty();
     * * flatMap(Function mapper);// 与map类似。返回值是Optional
     */
    @Test
    public void test5() {
        Optional<Employee> op1 = Optional.ofNullable(new Employee("张三"));
        System.out.println(op1.orElse(new Employee()));
        System.out.println(op1.orElse(null));
    }

    /**
     * orElseGet(Supplier s);  // 如果调用对象包含值，返回该值，否则返回s中获取的值
     */
    @Test
    public void test6() {
        Optional<Employee> op1 = Optional.of(new Employee("田七"));
        op1 = Optional.empty();
        Employee employee = op1.orElseGet(() -> new Employee());
        System.out.println(employee);
    }

    /**
     * map(Function f): // 如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty();
     */
    @Test
    public void test7() {
        Optional<Employee> op1 = Optional.of(new Employee(11,"田七"));
        System.out.println(op1.map((e) -> e.getId()).get());
    }
}
